/**
 * 场景管理相关API
 * 封装场景列表、详情、触发条件、执行动作等功能的接口
 */

import request from './request.js';

// API路径配置
const API_ROUTES = {
  SCENE: {
    // 场景基础操作
    LIST: '/api/scenes/list',               // 获取场景列表
    DETAIL: '/api/scenes/detail',           // 获取场景详情
    CREATE: '/api/scenes/create',           // 创建场景
    UPDATE: '/api/scenes/update',           // 更新场景
    DELETE: '/api/scenes/delete',           // 删除场景
    ENABLE: '/api/scenes/enable',           // 启用场景
    DISABLE: '/api/scenes/disable',         // 禁用场景
    
    // 场景条件
    CONDITIONS: '/api/scenes/conditions',   // 获取场景条件
    ADD_CONDITION: '/api/scenes/condition/add', // 添加条件
    UPDATE_CONDITION: '/api/scenes/condition/update', // 更新条件
    DELETE_CONDITION: '/api/scenes/condition/delete', // 删除条件
    
    // 场景动作
    ACTIONS: '/api/scenes/actions',         // 获取场景动作
    ADD_ACTION: '/api/scenes/action/add',   // 添加动作
    UPDATE_ACTION: '/api/scenes/action/update', // 更新动作
    DELETE_ACTION: '/api/scenes/action/delete', // 删除动作
    
    // 场景执行
    EXECUTE: '/api/scenes/execute',         // 手动执行场景
    HISTORY: '/api/scenes/history',         // 获取执行历史
    
    // 场景统计
    STATS: '/api/scenes/stats',             // 场景统计
  }
};

/**
 * 场景API封装
 */
export default {
  /**
   * 获取场景列表
   * @param {Object} params - 查询参数 {unitId, type, status, page, limit}
   * @returns {Promise} 场景列表数据
   */
  getSceneList(params = {}) {
    return request({
      url: API_ROUTES.SCENE.LIST,
      method: 'GET',
      data: params
    });
  },
  
  /**
   * 获取场景详情
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 场景详情数据
   */
  getSceneDetail(sceneId) {
    return request({
      url: API_ROUTES.SCENE.DETAIL,
      method: 'GET',
      data: { sceneId }
    });
  },
  
  /**
   * 创建场景
   * @param {Object} sceneData - 场景数据
   * @returns {Promise} 创建结果
   */
  createScene(sceneData) {
    return request({
      url: API_ROUTES.SCENE.CREATE,
      method: 'POST',
      data: sceneData
    });
  },
  
  /**
   * 更新场景
   * @param {Object} sceneData - 场景数据，包含sceneId
   * @returns {Promise} 更新结果
   */
  updateScene(sceneData) {
    return request({
      url: API_ROUTES.SCENE.UPDATE,
      method: 'PUT',
      data: sceneData
    });
  },
  
  /**
   * 删除场景
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 删除结果
   */
  deleteScene(sceneId) {
    return request({
      url: API_ROUTES.SCENE.DELETE,
      method: 'DELETE',
      data: { sceneId }
    });
  },
  
  /**
   * 启用场景
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 启用结果
   */
  enableScene(sceneId) {
    return request({
      url: API_ROUTES.SCENE.ENABLE,
      method: 'PUT',
      data: { sceneId }
    });
  },
  
  /**
   * 禁用场景
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 禁用结果
   */
  disableScene(sceneId) {
    return request({
      url: API_ROUTES.SCENE.DISABLE,
      method: 'PUT',
      data: { sceneId }
    });
  },
  
  /**
   * 获取场景条件
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 条件数据
   */
  getSceneConditions(sceneId) {
    return request({
      url: API_ROUTES.SCENE.CONDITIONS,
      method: 'GET',
      data: { sceneId }
    });
  },
  
  /**
   * 添加场景条件
   * @param {String} sceneId - 场景ID
   * @param {Object} conditionData - 条件数据
   * @returns {Promise} 添加结果
   */
  addSceneCondition(sceneId, conditionData) {
    return request({
      url: API_ROUTES.SCENE.ADD_CONDITION,
      method: 'POST',
      data: {
        sceneId,
        ...conditionData
      }
    });
  },
  
  /**
   * 更新场景条件
   * @param {String} sceneId - 场景ID
   * @param {String} conditionId - 条件ID
   * @param {Object} conditionData - 条件数据
   * @returns {Promise} 更新结果
   */
  updateSceneCondition(sceneId, conditionId, conditionData) {
    return request({
      url: API_ROUTES.SCENE.UPDATE_CONDITION,
      method: 'PUT',
      data: {
        sceneId,
        conditionId,
        ...conditionData
      }
    });
  },
  
  /**
   * 删除场景条件
   * @param {String} sceneId - 场景ID
   * @param {String} conditionId - 条件ID
   * @returns {Promise} 删除结果
   */
  deleteSceneCondition(sceneId, conditionId) {
    return request({
      url: API_ROUTES.SCENE.DELETE_CONDITION,
      method: 'DELETE',
      data: {
        sceneId,
        conditionId
      }
    });
  },
  
  /**
   * 获取场景动作
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 动作数据
   */
  getSceneActions(sceneId) {
    return request({
      url: API_ROUTES.SCENE.ACTIONS,
      method: 'GET',
      data: { sceneId }
    });
  },
  
  /**
   * 添加场景动作
   * @param {String} sceneId - 场景ID
   * @param {Object} actionData - 动作数据
   * @returns {Promise} 添加结果
   */
  addSceneAction(sceneId, actionData) {
    return request({
      url: API_ROUTES.SCENE.ADD_ACTION,
      method: 'POST',
      data: {
        sceneId,
        ...actionData
      }
    });
  },
  
  /**
   * 更新场景动作
   * @param {String} sceneId - 场景ID
   * @param {String} actionId - 动作ID
   * @param {Object} actionData - 动作数据
   * @returns {Promise} 更新结果
   */
  updateSceneAction(sceneId, actionId, actionData) {
    return request({
      url: API_ROUTES.SCENE.UPDATE_ACTION,
      method: 'PUT',
      data: {
        sceneId,
        actionId,
        ...actionData
      }
    });
  },
  
  /**
   * 删除场景动作
   * @param {String} sceneId - 场景ID
   * @param {String} actionId - 动作ID
   * @returns {Promise} 删除结果
   */
  deleteSceneAction(sceneId, actionId) {
    return request({
      url: API_ROUTES.SCENE.DELETE_ACTION,
      method: 'DELETE',
      data: {
        sceneId,
        actionId
      }
    });
  },
  
  /**
   * 手动执行场景
   * @param {String} sceneId - 场景ID
   * @returns {Promise} 执行结果
   */
  executeScene(sceneId) {
    return request({
      url: API_ROUTES.SCENE.EXECUTE,
      method: 'POST',
      data: { sceneId }
    });
  },
  
  /**
   * 获取场景执行历史
   * @param {String} sceneId - 场景ID
   * @param {Object} params - 查询参数 {timeRange, page, limit}
   * @returns {Promise} 历史数据
   */
  getSceneHistory(sceneId, params = {}) {
    return request({
      url: API_ROUTES.SCENE.HISTORY,
      method: 'GET',
      data: {
        sceneId,
        ...params
      }
    });
  },
  
  /**
   * 获取场景统计
   * @param {Object} params - 查询参数 {unitId, timeRange}
   * @returns {Promise} 统计数据
   */
  getSceneStats(params = {}) {
    return request({
      url: API_ROUTES.SCENE.STATS,
      method: 'GET',
      data: params
    });
  }
}; 